home *** CD-ROM | disk | FTP | other *** search
/ MACD 5 / MACD 5.bin / workbench / tools / czesc_4 / ykick / addmem.c < prev    next >
C/C++ Source or Header  |  1993-10-01  |  9KB  |  301 lines
  1.  
  2. /*
  3.  *  ADDMEM (c)Copyright 1991 by Tobias Ferber.  Alle Rechte vorbehalten.
  4.  *
  5.  *  Modifiziert am Sat Aug 15 02:19:32 1992
  6.  *   + ADDMEM kann jetzt die vorhanden memory areas ausgeben
  7.  *   + Seit heute steht ADDMEM unter der Obhut von RCS ;)
  8.  *  Sun Feb 14 03:12:23 1993
  9.  *   + cheatboard() added.
  10.  */
  11.  
  12. #include <exec/types.h>
  13. #include <exec/memory.h>
  14. #include <exec/execbase.h>
  15. #include <libraries/expansion.h>
  16. #include <libraries/configregs.h>
  17. #include <libraries/configvars.h>
  18. #include <stdio.h>
  19.  
  20. extern struct ExecBase *SysBase;
  21. struct ExpansionBase *ExpansionBase;
  22.  
  23. BOOL ExistMem(lower,upper)
  24. /*
  25.  *  ExistMem() schaut in der MemList nach ob es bereits einen
  26.  *  Speicherbereich gibt, der die Einbindung eines Bereiches von
  27.  *  <lower> bis <upper> verbietet.  Dies ist genau dann der Fall,
  28.  *  wenn dort ein Speicherbereich S existiert, der Teil- oder
  29.  *  Obermege von [lower..upper] ist.  In diesem Fall ist ExistMem()
  30.  *  TRUE, andrenfalls FALSE.
  31.  */
  32. long lower;  /* untere /         Grenze des zu testenden */
  33. long upper;  /*       /  obere   Bereichs                */
  34. {
  35.   struct MemHeader *mh;
  36.   long u,l;
  37.  
  38.   BOOL overlap= FALSE;
  39.  
  40.   Forbid();
  41.   for(mh = (struct MemHeader *)SysBase->MemList.lh_Head;
  42.       mh->mh_Node.ln_Succ;
  43.       mh = (struct MemHeader *)mh->mh_Node.ln_Succ)
  44.   {
  45.     l= (long)mh->mh_Lower;
  46.     u= (long)mh->mh_Upper;
  47.  
  48.     overlap |= (l< lower && u> lower ||
  49.                 l< upper && u> upper ||
  50.                 l>=lower && u<=upper );
  51.   }
  52.   Permit();
  53.  
  54.   return(overlap);
  55. }
  56.  
  57. BOOL SafeAddMemList(size, attributes, pri, base, name)
  58. /*
  59.  *  SafeAddMemList() klinkt einen Speicherblock in die Liste
  60.  *  des Systempools ein.  Die Parameter und deren Bedeutung
  61.  *  sind die identisch mit denen von EXEC's AddMemList().
  62.  *  Im Unterschied zu AddMemList() wird hier ueberprueft ob
  63.  *  schon Speicher in dem angegebenen Bereich vorhanden ist.
  64.  *  Ausserdem wird der Name des Speicherbereichs in einen
  65.  *  PUBLIC bereich kopiert, kann also nach dem Funktionsaufruf
  66.  *  wieder freigegeben werden.
  67.  */
  68. ULONG size;        /* groesse des Speicherbereichs (in Bytes) */
  69. ULONG attributes;  /* MEMF_XXXX Typ des Pools */
  70. LONG pri;          /* Je hoeher die Prioritaet (CHIP hat -10) desto
  71.                     * naeher liegt der Speicher am Listenkopf
  72.                     */
  73. APTR base;         /* Startadresse des Speicherbereichs */
  74. STRPTR name;       /* (optionaler) Name fuer den Speicherbereich */
  75. {
  76.   BOOL fail= ExistMem((long)base,(long)base+size);
  77.   char *s= (char *)NULL;
  78.  
  79.   if(!fail)
  80.   {
  81.     if(strlen(name) > 0)
  82.     { s= (char *)AllocMem(strlen(name)+1, MEMF_PUBLIC);  /* + EOS */
  83.       strcpy(s,name);
  84.     }
  85.  
  86.     AddMemList(size,attributes,pri,base,s);
  87.   }
  88.  
  89.   return(fail);
  90. }
  91.  
  92.  
  93. #define EMAX 17  /* max. #of expansions */
  94.  
  95. void showmem()
  96. {
  97.   struct MemHeader *mh;
  98.   long lower[EMAX],   /* lower memory bound */
  99.        upper[EMAX];   /* upper memory bound */
  100.   short attr[EMAX],   /* characteristics of this region */
  101.         m=0;
  102.  
  103.   Forbid();
  104.   for (mh = (struct MemHeader *)SysBase->MemList.lh_Head;
  105.        mh->mh_Node.ln_Succ;
  106.        mh = (struct MemHeader *)mh->mh_Node.ln_Succ)
  107.   {
  108.     if(m < EMAX)
  109.     { lower[m]= (long)mh->mh_Lower;
  110.       upper[m]= (long)mh->mh_Upper;
  111.       attr[m]= (short)mh->mh_Attributes;
  112.       ++m;
  113.     }
  114.   }
  115.   Permit();
  116.  
  117.   while(--m >= 0)
  118.   { printf("$%06lx..$%06lx:  ",lower[m],upper[m]);
  119.     if(attr[m] & MEMF_PUBLIC)   printf("PUBLIC ");
  120.     if(attr[m] & MEMF_CHIP)     printf("CHIP ");
  121.     if(attr[m] & MEMF_FAST)     printf("FAST ");
  122.     if(attr[m] & MEMF_LOCAL)    printf("LOCAL ");
  123.     if(attr[m] & MEMF_24BITDMA) printf("24BITDMA ");
  124.     if(attr[m] & MEMF_KICK)     printf("KICK ");
  125.     if(attr[m]== MEMF_ANY)      printf("ANY");
  126.     putchar('\n');
  127.   }
  128. }
  129.  
  130.  
  131. long cheatboard(APTR base, long size)
  132. {
  133.   long panic=-1;
  134.  
  135.   static char *bsn[8]= {
  136.     "8meg", "64k", "128k","256k", "512k", "1meg", "2meg", "4meg" };
  137.  
  138.   ExpansionBase= (struct ExpansionBase *)OpenLibrary(EXPANSIONNAME,0L);
  139.   if(ExpansionBase)
  140.   { struct ConfigDev *cd= (struct ConfigDev *)AllocConfigDev();
  141.       /*AllocMem(sizeof(struct ConfigDev),MEMF_PUBLIC|MEMF_CLEAR);*/
  142.     if(cd)
  143.     { panic= ReadExpansionRom(0x200000,cd);
  144.  
  145.       if(panic==0)
  146.       { cd->cd_BoardAddr = base;
  147.         ConfigBoard(size,cd);
  148.       }
  149.       else
  150.       {
  151.         cd->cd_Flags= CDF_CONFIGME;  /* board needs a driver to claim it */
  152.         cd->cd_Rom.er_Product= 0;    /* number assigned by manufacturer */
  153.  
  154.         /*
  155.          * We'll use a special "hacker" Manufacturer ID number
  156.          * which is reserved for test use: 2011 (0x07DB = -0xF824)
  157.          * (Unique ID, ASSIGNED BY COMMODORE-AMIGA!)
  158.          */
  159.  
  160.         cd->cd_Rom.er_Manufacturer= 2011;
  161.         cd->cd_Rom.er_SerialNumber= panic; /* ;) */
  162.  
  163.         /*
  164.          * board size: 0x00 =   8M
  165.          *             0x01 =  64k
  166.          *             0x02 = 128k
  167.          *             0x03 = 256k
  168.          *             0x04 = 512k
  169.          *             0x05 =   1M
  170.          *             0x06 =   2M
  171.          *             0x07 =   4M
  172.          */
  173.  
  174.         { long s,t;
  175.           for(s= (size>>16) & 0xFFFF, t=0; s>0; s>>=1, (t++)%=8)
  176.             ;
  177.           cd->cd_Rom.er_Type= t | ERT_NEWBOARD | ERTF_MEMLIST;
  178.         }
  179.  
  180.         cd->cd_BoardAddr= base;  /* where in mem the board was placed */
  181.         cd->cd_BoardSize= size;  /* size of board in bytes */
  182.         cd->cd_SlotAddr= 0x60;
  183.         cd->cd_SlotSize= 32;
  184.  
  185.         AddConfigDev(cd);
  186.       }
  187.       printf("%d/%d board cheated @$%06lx w/ %s Mem.\n",
  188.         cd->cd_Rom.er_Manufacturer,
  189.         cd->cd_Rom.er_SerialNumber,
  190.         cd->cd_BoardAddr,
  191.         bsn[cd->cd_Rom.er_Type & 7] );
  192.     }
  193.     CloseLibrary(ExpansionBase);
  194.   }
  195.   return(panic);
  196. }
  197.  
  198. /*------------------------------------------------------------------------*/
  199.  
  200. const char *wasgehtdennhier=
  201.   "$Id: addmem.c,v 1.2 93/02/14 04:27:30 tf Exp $\n"
  202.   "(c)Copyright 1991 by Tobias Ferber, All Rights Reserved.\n"
  203.   "ADDMEM <lower-hex> <upper-hex> [-p <pri>] [-n <name>] [-a <attr>]";
  204.  
  205. /*------------------------------------------------------------------------*/
  206.  
  207. void main(int argc, char *argv[])
  208. {
  209.   char *name= (char *)NULL;
  210.  
  211.   long start  = 0,
  212.        end    = 0,
  213.        pri    = 0,
  214.        lie    = 0,
  215.        attr   = MEMF_FAST|MEMF_PUBLIC;
  216.  
  217.   BOOL fuckit= FALSE;
  218.  
  219.   if(argc>1)
  220.   { --argc;
  221.     ++argv;
  222.  
  223.     while(argc>0 && !fuckit)
  224.     { char *arg= argv[0];
  225.       if(*arg=='-')
  226.       { arg++;
  227.         switch(*arg)
  228. /**/    { case 'p': case 'P':
  229.             if(arg[1]) pri= atol(&arg[1]);
  230.             else { argv++;
  231.                    argc--;
  232.                    if(argc>0) pri= atol(argv[0]);
  233.                    else pri=0;
  234.                  }
  235.             if(pri<-128 || pri>127)
  236.             { puts("Invalid priority %d, should be in [-128..127]");
  237.               fuckit=TRUE;
  238.             }
  239.             break;
  240. /**/      case 'a': case 'A':
  241.             if(arg[1]) attr= atol(&arg[1]);
  242.             else { argv++;
  243.                    argc--;
  244.                    if(argc>0) attr= atol(argv[0]);
  245.                    else attr= MEMF_FAST|MEMF_PUBLIC;
  246.                  }
  247.             break;
  248. /**/      case 'n': case 'N':
  249.             if(arg[1]) name= &arg[1];
  250.             else { argv++;
  251.                    argc--;
  252.                    if(argc>0) name= argv[0];
  253.                    else name= (char *)NULL;
  254.                  }
  255.             break;
  256.           case 'b': case 'B':  lie=1;
  257.                                break;
  258. /**/      default:  printf("bad option -%c.\n",*arg);
  259.                     fuckit=TRUE;
  260.                     break;
  261.         }
  262.       }
  263.       else if(*arg=='?')
  264.       { showmem();
  265.         exit(0);
  266.       }
  267.       else if(start==0 || end==0)
  268.       {
  269.         long t;
  270.         if(arg[0]=='$') arg= &arg[1];
  271.         else if(arg[0]=='0' && (arg[1]=='x' || arg[1]=='X')) arg= &arg[2];
  272.         sscanf(arg,"%lx",&t);
  273.         if(t&1) { puts("Address error.");
  274.                   fuckit=TRUE;
  275.                 }
  276.         if(start==0) start=t;
  277.         else end=t;
  278.       }
  279.       else fuckit=TRUE;
  280.       --argc;
  281.       ++argv;
  282.     }
  283.     fuckit |= (start==0 || end==0);
  284.  
  285.     if(!fuckit)
  286.     { if( fuckit= SafeAddMemList( end-start,
  287.                                   MEMF_FAST|MEMF_PUBLIC,
  288.                                   pri,
  289.                                   (APTR)start,
  290.                                   name) )
  291.       { puts("Failure -- memory area already exists.");
  292.         showmem();
  293.       }
  294.       else printf("%ld bytes added to the system free pool.\n",end-start);
  295.       if(lie) cheatboard((APTR)start,end-start);
  296.     }
  297.   }
  298.   else puts(wasgehtdennhier);  /* no args */
  299.   exit(fuckit?20:0);
  300. }
  301.